package is.api.demo.isgateway.utils;

import java.nio.charset.Charset;
import java.util.Collection;
import java.util.Iterator;

/**
 * 字符工具类
 *
 * @author jinlong.wang
 */
public abstract class IsGateWayStringUtils {
    /**
     * 空字符
     */
    public static final String EMPTY = "";

    /**
     * 判断字符串是否为空
     *
     * @param str 输入判断
     * @return 输出结果
     */
    public static boolean isEmpty(String str) {
        return (str == null || "".equals(str));
    }


    /**
     * 拼接数组为字符串
     *
     * @param array     数组
     * @param separator 分隔符
     * @return 拼接后的字符串信息
     */
    public static String join(final Object[] array, final String separator) {
        if (array == null) {
            return null;
        }
        return join(array, separator, 0, array.length);
    }

    /**
     * 拼接数组为字符串
     *
     * @param array      数组
     * @param separator  分隔符
     * @param startIndex 参与拼接的数组开始下标
     * @param endIndex   参与拼接的数组结束下标
     * @return 拼接后的字符串信息
     */
    public static String join(final Object[] array, String separator, final int startIndex, final int endIndex) {
        if (array == null) {
            return null;
        }
        if (separator == null) {
            separator = EMPTY;
        }

        // endIndex - startIndex > 0:   Len = NofStrings *(len(firstString) + len(separator))
        //           (Assuming that all Strings are roughly equally long)
        final int noOfItems = endIndex - startIndex;
        if (noOfItems <= 0) {
            return EMPTY;
        }

        final StringBuilder buf = new StringBuilder(noOfItems * 16);

        for (int i = startIndex; i < endIndex; i++) {
            if (i > startIndex) {
                buf.append(separator);
            }
            if (array[i] != null) {
                buf.append(array[i]);
            }
        }
        return buf.toString();
    }

    /**
     * 对集合进行拼接
     *
     * @param collection 迭代器对象
     * @param separator  分隔符
     * @return 拼接后的字符串信息
     */
    public static String join(Collection collection, String separator) {
        return collection == null ? null : join(collection.iterator(), separator);
    }

    /**
     * 对迭代器对象进行拼接
     *
     * @param iterator  迭代器对象
     * @param separator 分隔符
     * @return 拼接后的字符串信息
     */
    public static String join(Iterator iterator, String separator) {
        if (iterator == null) {
            return null;
        } else if (!iterator.hasNext()) {
            return "";
        } else {
            Object first = iterator.next();
            if (!iterator.hasNext()) {
                return first == null ? "" : first.toString();
            } else {
                StringBuilder buf = new StringBuilder(256);
                if (first != null) {
                    buf.append(first);
                }

                while (iterator.hasNext()) {
                    if (separator != null) {
                        buf.append(separator);
                    }

                    Object obj = iterator.next();
                    if (obj != null) {
                        buf.append(obj);
                    }
                }

                return buf.toString();
            }
        }
    }

    /**
     * 断字符序列是否不为空
     *
     * @param str 字符串
     * @return 不为空返回true
     */
    public static boolean hasLength(CharSequence str) {
        return str != null && str.length() > 0;
    }

    /**
     * 判断字符串是否不为空
     *
     * @param str 字符串
     * @return 不为空返回true
     */
    public static boolean hasLength(String str) {
        return str != null && !str.isEmpty();
    }

    /**
     * 集合组装成字符串
     *
     * @param coll   集合
     * @param delim  分隔符
     * @param prefix 前缀
     * @param suffix 后缀
     * @return 字符
     */
    public static String collectionToDelimitedString(Collection<?> coll, String delim, String prefix, String suffix) {

        if (coll == null) {
            return "";
        }

        StringBuilder sb = new StringBuilder();
        Iterator<?> it = coll.iterator();
        while (it.hasNext()) {
            sb.append(prefix).append(it.next()).append(suffix);
            if (it.hasNext()) {
                sb.append(delim);
            }
        }
        return sb.toString();
    }

    /**
     * 集合拼接成字符串
     *
     * @param coll  集合
     * @param delim 指定符号分隔
     * @return 字符
     */
    public static String collectionToDelimitedString(Collection<?> coll, String delim) {
        return collectionToDelimitedString(coll, delim, "", "");
    }

    /**
     * 集合拼接成字符串
     *
     * @param coll 集合
     * @return 字符 （以  “,”号分隔）
     */
    public static String collectionToCommaDelimitedString(Collection<?> coll) {
        return collectionToDelimitedString(coll, ",");
    }

    /**
     * 判断字符是否为空
     *
     * @param cs 输入字符
     * @return 如果为null 或则empty 则返回true
     */
    public static boolean isEmpty(CharSequence cs) {
        return cs == null || cs.length() == 0;
    }

    /**
     * 判断字符是否是数值形式
     *
     * @param cs 输入字符
     * @return 如果是数值则返回true
     */
    public static boolean isNumeric(CharSequence cs) {
        if (isEmpty(cs)) {
            return false;
        } else {
            int sz = cs.length();
            for (int i = 0; i < sz; ++i) {
                if (!Character.isDigit(cs.charAt(i))) {
                    return false;
                }
            }

            return true;
        }
    }

    /**
     * 首字母大小写
     *
     * @param str        字段串
     * @param capitalize 首字母是否大写
     * @return 首字母大小写字符
     */
    private static String changeFirstCharacterCase(String str, boolean capitalize) {
        if (!hasLength(str)) {
            return str;
        }
        char baseChar = str.charAt(0);
        char updatedChar;
        if (capitalize) {
            updatedChar = Character.toUpperCase(baseChar);
        } else {
            updatedChar = Character.toLowerCase(baseChar);
        }
        if (baseChar == updatedChar) {
            return str;
        }

        char[] chars = str.toCharArray();
        chars[0] = updatedChar;
        return new String(chars, 0, chars.length);
    }

    /**
     * 获取字符对象的字节数组，按照utf-8编码方式提供
     *
     * @param str 源字符
     * @return 字节数组
     */
    public static byte[] getBytesUtf8(String str) {
        if (str == null) {
            return null;
        }
        return str.getBytes(Charset.forName("utf-8"));
    }

    /**
     * 判断字符序列是否不为空(去除字符中空格符)
     *
     * @param str 字符序列
     * @return 不为空返回true
     */
    public static boolean hasText(CharSequence str) {
        return (str != null && str.length() > 0 && containsText(str));
    }

    /**
     * 判断字符串是否不为空(去除字符中空格符)
     *
     * @param str 字符串
     * @return 不为空返回true
     */
    public static boolean hasText(String str) {
        return (str != null && !str.isEmpty() && containsText(str));
    }

    private static boolean containsText(CharSequence str) {
        int strLen = str.length();
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                return true;
            }
        }
        return false;
    }
}

